#!pip install -r requirements.txt

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import dill

from modules.trainer import Trainer
from modules.model import CustomAlexNet
from modules.dataset import CustomDataset

!pip freeze > requirements.txt

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
if torch.cuda.is_available():
    print(f"GPU Properties: {torch.cuda.get_device_properties(torch.cuda.current_device())}")

GPU Properties: _CudaDeviceProperties(name='NVIDIA GeForce GTX 1650', major=7, minor=5, total_memory=4095MB, multi_processor_count=16)

custom_dataset = CustomDataset(root_dir='dataset')

model = CustomAlexNet(num_classes=custom_dataset.num_classes, dropout_p=0.5, fc1_out=4096, fc2_out=4096, activation=nn.ReLU).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# Classifier Trainer
trainer = Trainer(model, custom_dataset.train_loader, custom_dataset.val_loader, criterion, optimizer, device,"default")
trainer.train(50)
trainer.best_val_loss

Folder already exists: weights

Epoch 1/50: 100%|███████████████████████████████████████████████████████████████████| 10/10 [00:05<00:00,  1.90batch/s]

+-------+-------+--------+----------+-----------+--------+----------+--------+---------------+
| Epoch | Stage |  Loss  | Accuracy | Precision | Recall | F1-Score |  MCC   | Cohen's Kappa |
+-------+-------+--------+----------+-----------+--------+----------+--------+---------------+
|   1   | Train | 1.5434 |  0.3864  |   0.3240  | 0.3864 |  0.3261  | 0.0377 |     0.0325    |
+-------+-------+--------+----------+-----------+--------+----------+--------+---------------+

Validation 1/50: 100%|██████████████████████████████████████████████████████████████| 20/20 [00:00<00:00, 33.62batch/s]

+-------+------------+--------+----------+-----------+--------+----------+--------+---------------+
| Epoch |   Stage    |  Loss  | Accuracy | Precision | Recall | F1-Score |  MCC   | Cohen's Kappa |
+-------+------------+--------+----------+-----------+--------+----------+--------+---------------+
|   1   | Validation | 1.2678 |  0.4351  |   0.3195  | 0.4351 |  0.3233  | 0.1817 |     0.1257    |
+-------+------------+--------+----------+-----------+--------+----------+--------+---------------+

Epoch 2/50: 100%|███████████████████████████████████████████████████████████████████| 10/10 [00:03<00:00,  3.17batch/s]

+-------+-------+--------+----------+-----------+--------+----------+--------+---------------+
| Epoch | Stage |  Loss  | Accuracy | Precision | Recall | F1-Score |  MCC   | Cohen's Kappa |
+-------+-------+--------+----------+-----------+--------+----------+--------+---------------+
|   2   | Train | 1.1975 |  0.5633  |   0.4277  | 0.5633 |  0.4850  | 0.3199 |     0.2993    |
+-------+-------+--------+----------+-----------+--------+----------+--------+---------------+

Validation 2/50: 100%|██████████████████████████████████████████████████████████████| 20/20 [00:00<00:00, 30.46batch/s]

+-------+------------+--------+----------+-----------+--------+----------+--------+---------------+
| Epoch |   Stage    |  Loss  | Accuracy | Precision | Recall | F1-Score |  MCC   | Cohen's Kappa |
+-------+------------+--------+----------+-----------+--------+----------+--------+---------------+
|   2   | Validation | 1.1557 |  0.5455  |   0.4130  | 0.5455 |  0.4527  | 0.3606 |     0.3071    |
+-------+------------+--------+----------+-----------+--------+----------+--------+---------------+

Epoch 3/50: 100%|███████████████████████████████████████████████████████████████████| 10/10 [00:02<00:00,  3.41batch/s]

import random
global index
index = 0
def create_individual():
    dropout_p = random.choice([0.2,0.4, 0.5, 0.7])
    fc1_out = random.choice([512,1024, 2048, 4096])
    fc2_out = random.choice([512,1024, 2048, 4096])
    return (dropout_p, fc1_out, fc2_out)

def initialize_population(population_size):
    return [create_individual() for _ in range(population_size)]

def selection(population, scores, k=3):
    selected_indices = sorted(range(len(scores)), key=lambda i: scores[i])[:k]
    return [population[i] for i in selected_indices]

def crossover(parent1, parent2):
    crossover_point = random.randint(1, len(parent1) - 1)
    child1 = parent1[:crossover_point] + parent2[crossover_point:]
    child2 = parent2[:crossover_point] + parent1[crossover_point:]
    return child1, child2

def mutate(individual, mutation_prob=0.1):
    mutated_individual = list(individual)
    for i in range(len(mutated_individual)):
        if random.random() < mutation_prob:
            if i == 0:  # dropout_p için
                mutated_individual[i] = random.choice([0.2,0.4, 0.5, 0.7])
            elif i == 1:  # fc1_out için
                mutated_individual[i] = random.choice([512,1024, 2048, 4096])
            elif i == 2:  # fc2_out için
                mutated_individual[i] = random.choice([512,1024, 2048, 4096])
    return tuple(mutated_individual)

def evaluate_individual(individual,generation):
    global index  # Global değişkeni belirtelim
    index += 1
    dropout_p, fc1_out, fc2_out = individual
    # Model oluşturma
    model = CustomAlexNet(num_classes=custom_dataset.num_classes, dropout_p=dropout_p, fc1_out=fc1_out, fc2_out=fc2_out)
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)
    cfg="genetic_algo_"+str(generation)+"_"+str(index)
    trainer = Trainer(model, custom_dataset.train_loader, custom_dataset.val_loader, criterion, optimizer, device,cfg)
    trainer.train(50)
    return trainer.best_val_loss  # Burada doğruluk da döndürebilirsiniz

# Genetik algoritma parametreleri
population_size = 10
num_generations = 5

# Başlangıç popülasyonunu oluştur
population = initialize_population(population_size)
general_best_fitness=np.inf
general_best_individual=None
# Genetik algoritma ana döngüsü
for generation in range(num_generations):
    # Uygunluk değerlerini hesapla
    fitness_scores = [evaluate_individual(individual,generation) for individual in population]
    
    # En iyi bireyi seç
    best_individual_index = min(range(len(fitness_scores)), key=lambda i: fitness_scores[i])
    best_individual = population[best_individual_index]
    best_fitness = fitness_scores[best_individual_index]
    print(f"Generation {generation}: Best individual - {best_individual}, Best fitness - {best_fitness}")
    if(best_fitness<general_best_fitness):
        general_best_fitness=best_fitness
        general_best_individual=best_individual
    # Yeni nesil oluştur
    new_population = []
    while len(new_population) < population_size:
        parent1, parent2 = selection(population, fitness_scores, k=2)
        child1, child2 = crossover(parent1, parent2)
        child1 = mutate(child1)
        child2 = mutate(child2)
        new_population.extend([child1, child2])
    
    population = new_population[:population_size]
print(f"Best individual - {general_best_individual}, Best fitness - {general_best_fitness}")

Folder already exists: weights

Epoch 1/50: 100%|███████████████████████████████████████████████████████████████████| 10/10 [00:02<00:00,  3.54batch/s]

+-------+-------+--------+----------+-----------+--------+----------+--------+---------------+
| Epoch | Stage |  Loss  | Accuracy | Precision | Recall | F1-Score |  MCC   | Cohen's Kappa |
+-------+-------+--------+----------+-----------+--------+----------+--------+---------------+
|   1   | Train | 1.3506 |  0.3474  |   0.2972  | 0.3474 |  0.2624  | 0.0073 |     0.0055    |
+-------+-------+--------+----------+-----------+--------+----------+--------+---------------+

Validation 1/50: 100%|██████████████████████████████████████████████████████████████| 20/20 [00:00<00:00, 33.25batch/s]

+-------+------------+--------+----------+-----------+--------+----------+--------+---------------+
| Epoch |   Stage    |  Loss  | Accuracy | Precision | Recall | F1-Score |  MCC   | Cohen's Kappa |
+-------+------------+--------+----------+-----------+--------+----------+--------+---------------+
|   1   | Validation | 1.2655 |  0.5325  |   0.3888  | 0.5325 |  0.4410  | 0.3243 |     0.2862    |
+-------+------------+--------+----------+-----------+--------+----------+--------+---------------+

Epoch 2/50: 100%|███████████████████████████████████████████████████████████████████| 10/10 [00:02<00:00,  3.82batch/s]

+-------+-------+--------+----------+-----------+--------+----------+--------+---------------+
| Epoch | Stage |  Loss  | Accuracy | Precision | Recall | F1-Score |  MCC   | Cohen's Kappa |
+-------+-------+--------+----------+-----------+--------+----------+--------+---------------+
|   2   | Train | 1.1270 |  0.5714  |   0.4316  | 0.5714 |  0.4917  | 0.3313 |     0.3112    |
+-------+-------+--------+----------+-----------+--------+----------+--------+---------------+

Validation 2/50: 100%|██████████████████████████████████████████████████████████████| 20/20 [00:00<00:00, 32.57batch/s]

+-------+------------+--------+----------+-----------+--------+----------+--------+---------------+
| Epoch |   Stage    |  Loss  | Accuracy | Precision | Recall | F1-Score |  MCC   | Cohen's Kappa |
+-------+------------+--------+----------+-----------+--------+----------+--------+---------------+
|   2   | Validation | 1.2769 |  0.5000  |   0.4109  | 0.5000 |  0.4106  | 0.3125 |     0.2399    |
+-------+------------+--------+----------+-----------+--------+----------+--------+---------------+

Epoch 3/50: 100%|███████████████████████████████████████████████████████████████████| 10/10 [00:02<00:00,  3.78batch/s]

dill.dump_session('session.db')

dill.load_session('session.db')

Install Dependencies¶

Import Dependencies¶

Define Device¶

Dataset Creator¶

Training With Default Configuration¶